Preview
Name
fog_coord
Name Strings
GL_EXT_fog_coord
Version
$Date: 1998/05/04 20:01:22 $ $Revision: 1.5 $
Number
149
Dependencies
OpenGL 1.1 is required. fog_coord is written against the OpenGL 1.2
specification (available from www.opengl.org) to make the spec
forward-looking, although no 1.2 features are required.
Overview
This extension allows specifying an explicit per-vertex fog coord to be
used in fog computations, rather than using a fragment depth-based fog
equation.
Issues
* Should the specified value be used directly as the fog weighting factor,
or in place of the z input to the fog equations?
As the z input; more flexible and meets ISV requests.
* Do we want vertex array entry points? Interleaved array formats?
Yes for entry points, no for interleaved formats, following the
argument for secondary_color.
* Which scalar types should FogCoord accept? The full range, or just the
unsigned and float versions? At the moment it follows Index(), which
takes unsigned byte, signed short, signed int, float, and double.
Since we're now specifying a number which behaves like an eye-space
distance, rather than a [0,1] quantity, integer types are less
useful. However, restricting the commands to floating-point forms
only introduces some nonorthogonality.
Restrict to only float and double, for now.
* Interpolation of the fog coordinate may be perspective-correct or not.
Should this be affected by PERSPECTIVE_CORRECTION_HINT, FOG_HINT, or
another to-be-defined hint?
PERSPECTIVE_CORRECTION_HINT; this is already defined to affect all
interpolated parameters. Admittedly this is a loss of orthogonality.
* Should the current fog coordinate be queryable?
Yes, but it's not returned by feedback.
* Control the fog coordinate source via an Enable instead of a fog
parameter?
No. We might want to add more sources later.
* Should the fog coordinate be restricted to non-negative values?
Perhaps. Eye-coordinate distance of fragments will be non-negative
due to clipping. Specifying explicit negative coordinates may result
in very large computed f values, although they are defined to be
clipped after computation.
* Use existing DEPTH enum instead of FRAGMENT_DEPTH? Change name of
FRAGMENT_DEPTH_EXT to FOG_FRAGMENT_DEPTH_EXT?
Use FRAGMENT_DEPTH_EXT; FOG_FRAGMENT_DEPTH_EXT is somewhat misleading, since
fragment depth itself has no dependence on fog.
New Procedures and Functions
void FogCoord[fd]EXT(T coord)
void FogCoord[fd]vEXT(T coord)
void FogCoordPointerEXT(enum type, sizei stride, void *pointer)
New Tokens
Accepted by the <pname> parameter of Fogi and Fogf:
FOG_COORDINATE_SOURCE_EXT 0x8450
Accepted by the <param> parameter of Fogi and Fogf:
FOG_COORDINATE_EXT 0x8451
FRAGMENT_DEPTH_EXT 0x8452
Accepted by the <pname> parameter of GetBooleanv, GetIntegerv,
GetFloatv, and GetDoublev:
CURRENT_FOG_COORDINATE_EXT 0x8453
FOG_COORDINATE_ARRAY_TYPE_EXT 0x8454
FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455
Accepted by the <pname> parameter of GetPointerv:
FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456
Accepted by the <array> parameter of EnableClientState and
DisableClientState:
FOG_COORDINATE_ARRAY_EXT 0x8457
Additions to Chapter 2 of the 1.2 Draft Specification (OpenGL Operation)
These changes describe a new current state type, the fog coordinate, and the
commands to specify it:
- (2.6, p. 12) Second paragraph changed to:
"Each vertex is specified with two, three, or four coordinates. In
addition, a current normal, current texture coordinates, current
color, and current fog coordinate may be used in processing each
vertex."
- 2.6.3, p. 19) First paragraph changed to
"The only GL commands that are allowed within any Begin/End pairs
are the commands for specifying vertex coordinates, vertex colors,
normal coordinates, texture coordinates, and fog coordinates (Vertex,
Color, Index, Normal, TexCoord, FogCoord)..."
- (2.7, p. 20) Insert the following paragraph following the third
paragraph describing current normals:
" The current fog coodinate is set using
void FogCoord[fd]EXT(T coord)
void FogCoord[fd]vEXT(T coord)."
The last paragraph is changed to read:
"The state required to support vertex specification consists of four
floating-point numbers to store the current texture coordinates s,
t, r, and q, one floating-point value to store the current fog
coordinate, four floating-point values to store the current RGBA
color, and one floating-point value to store the current color
index. There is no notion of a current vertex, so no state is
devoted to vertex coordinates. The initial values of s, t, and r of
the current texture coordinates are zero; the initial value of q is
one. The initial fog coordinate is zero. The initial current normal
has coordinates (0,0,1). The initial RGBA color is (R,G,B,A) =
(1,1,1,1). The initial color index is 1."
- (2.8, p. 21) Added fog coordinate command for vertex arrays:
Change first paragraph to read:
"The vertex specification commands described in section 2.7 accept
data in almost any format, but their use requires many command
executions to specify even simple geometry. Vertex data may also be
placed into arrays that are stored in the client's address space.
Blocks of data in these arrays may then be used to specify multiple
geometric primitives through the execution of a single GL command.
The client may specify up to seven arrays: one each to store edge
flags, texture coordinates, fog coordinates, colors, color indices,
normals, and vertices. The commands"
Add to functions listed following first paragraph:
void FogCoordPointerEXT(enum type, sizei stride, void *pointer)
Add to table 2.4 (p. 22):
Command Sizes Types
------- ----- -----
FogCoordPointerEXT 1 float,double
Starting with the second paragraph on p. 23, change to add
FOG_COORDINATE_ARRAY_EXT:
"An individual array is enabled or disabled by calling one of
void EnableClientState(enum array)
void DisableClientState(enum array)
with array set to EDGE_FLAG_ARRAY, TEXTURE_COORD_ARRAY,
FOG_COORDINATE_ARRAY_EXT, COLOR_ARRAY, INDEX_ARRAY, NORMAL_ARRAY, or
VERTEX_ARRAY, for the edge flag, texture coordinate, fog coordinate,
color, color index, normal, or vertex array, respectively.
The ith element of every enabled array is transferred to the GL by
calling
void ArrayElement(int i)
For each enabled array, it is as though the corresponding command
from section 2.7 or section 2.6.2 were called with a pointer to
element i. For the vertex array, the corresponding command is
Vertex<size><type>v, where <size> is one of [2,3,4], and <type> is
one of [s,i,f,d], corresponding to array types short, int, float,
and double respectively. The corresponding commands for the edge
flag, texture coordinate, fog coordinate, color, color, color index,
and normal arrays are EdgeFlagv, TexCoord<size><type>v,
FogCoord<type>v, Color<size><type>v, Index<type>v, and
Normal<type>v, respectively..."
Change pseudocode on p. 27 to disable fog coordinate array for canned
interleaved array formats. After the lines
DisableClientState(EDGE_FLAG_ARRAY);
DisableClientState(INDEX_ARRAY);
insert the line
DisableClientState(FOG_COORDINATE_ARRAY_EXT);
Substitute "seven" for every occurence of "six" in the final paragraph
on p. 27.
- (2.12, p. 41) Add fog coordinate to the current rasterpos state.
Change the first sentence of the first paragraph to read
"The state required for the current raster position consists of
three window coordinates x_w, y_w, and z_w, a clip coordinate w_c
value, an eye coordinate distance, a fog coordinate, a valid bit,
and associated data consisting of a color and texture coordinates."
Change the last paragraph to read
"The current raster position requires six single-precision
floating-point values for its x_w, y_w, and z_w window coordinates,
its w_c clip coordinate, its eye coordinate distance, and its fog
coordinate, a single valid bit, a color (RGBA color and color
index), and texture coordinates for associated data. In the initial
state, the coordinates and texture coordinates are both (0,0,0,1),
the fog coordinate is 0, the eye coordinate distance is 0, the valid
bit is set, the associated RGBA color is (1,1,1,1), and the
associated color index color is 1. In RGBA mode, the associated
color index always has its initial value; in color index mode, the
RGBA color always maintains its initial value."
- (3.10, p. 139) Change the second and third paragraphs to read
"This factor f may be computed according to one of three equations:"
f = exp(-d*c) (3.24)
f = exp(-(d*c)^2) (3.25)
f = (e-c)/(e-s) (3.26)
If the fog source (as defined below) is FRAGMENT_DEPTH_EXT, then c
is the eye-coordinate distance from the eye, (0 0 0 1) in eye
coordinates, to the fragment center. If the fog source is
FOG_COORDINATE_EXT, then c is the interpolated value of the fog
coordinate for this fragment. The equation and the fog source, along
with either d or e and s, is specified with
void Fog{if}(enum pname, T param);
void Fog{if}v(enum pname, T params);
If <pname> is FOG_MODE, then <param> must be, or <param> must point
to an integer that is one of the symbolic constants EXP, EXP2, or
LINEAR, in which case equation 3.24, 3.25, or 3.26,, respectively,
is selected for the fog calculation (if, when 3.26 is selected, e =
s, results are undefined). If <pname> is FOG_COORDINATE_SOURCE_EXT,
then <param> is or <params> points to an integer that is one of the
symbolic constants FRAGMENT_DEPTH_EXT or FOG_COORDINATE_EXT. If
<pname> is FOG_DENSITY, FOG_START, or FOG_END, then <param> is or
<params> points to a value that is d, s, or e, respectively. If d is
specified less than zero, the error INVALID_VALUE results."
- (3.10, p. 140) Change the last paragraph preceding section 3.11
to read
"The state required for fog consists of a three valued integer to
select the fog equation, three floating-point values d, e, and s, an
RGBA fog color and a fog color index, a two-valued integer to select
the fog coordinate source, and a single bit to indicate whether or
not fog is enabled. In the initial state, fog is disabled,
FOG_COORDINATE_SOURCE_EXT is FRAGMENT_DEPTH_EXT, FOG_MODE is EXP, d
= 1.0, e = 1.0, and s = 0.0; C_f = (0,0,0,0) and i_f=0."
Additions to Chapter 6 of the 1.2 Specification (State and State Requests)
None
Additions to the GLX Specification
None (we don't expect this extension to be used on GLX implementations; if
it is, new GLX enumerants for the fog coordinate will be introduced).
GLX Protocol
None (as for the GLX Specification)
Errors
INVALID_ENUM is generated if FogCoordPointerEXT parameter <type> is not
FLOAT or DOUBLE.
INVALID_VALUE is generated if FogCoordPointerEXT parameter <stride> is
negative.
New State
(table 6.5, p. 195)
Get Value Type Get Command Initial Value Description Sec Attribute
--------- ---- ----------- ------------- ----------- --- ---------
CURRENT_FOG_COORDINATE_EXT R GetIntegerv, 0 Current 2.7 current
GetFloatv fog coordinate
(table 6.6, p. 197)
Get Value Type Get Command Initial Value Description Sec Attribute
--------- ---- ----------- ------------- ----------- --- ---------
FOG_COORDINATE_ARRAY_EXT B IsEnabled False Fog coord array enable 2.8 vertex-array
FOG_COORDINATE_ARRAY_TYPE_EXT Z8 GetIntegerv FLOAT Type of fog coordinate 2.8 vertex-array
FOG_COORDINATE_ARRAY_STRIDE_EXT Z+ GetIntegerv 0 Stride between fog coords 2.8 vertex-array
FOG_COORDINATE_ARRAY_POINTER_EXT Y GetPointerv 0 Pointer to the fog coord array 2.8 vertex-array
(table 6.8, p. 198)
Get Value Type Get Command Initial Value Description Sec Attribute
--------- ---- ----------- ------------- ----------- --- ---------
FOG_COORDINATE_SOURCE_EXT Z2 GetIntegerv, FRAGMENT_DEPTH_EXT Source of fog 3.10 fog
GetFloatv coord for
fog calculation